/**
 * ***************************************************************************** Copyright (c)
 * 2012-2015 Red Hat, Inc. All rights reserved. This program and the accompanying materials are made
 * available under the terms of the Eclipse Public License v1.0 which accompanies this distribution,
 * and is available at http://www.eclipse.org/legal/epl-v10.html
 *
 * <p>Contributors: Red Hat, Inc. - initial API and implementation
 * *****************************************************************************
 */
package org.eclipse.che.ide.ext.java.jdt.text;

import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import org.eclipse.che.ide.api.editor.text.BadLocationException;
import org.eclipse.che.ide.api.editor.text.Region;
import org.eclipse.che.ide.api.editor.text.TypedRegion;
import org.eclipse.che.ide.api.editor.text.TypedRegionImpl;
import org.eclipse.che.ide.runtime.Assert;
import org.eclipse.che.ide.util.loging.Log;

/**
 * A collection of text functions.
 *
 * <p>This class is neither intended to be instantiated nor subclassed.
 *
 * @noinstantiate This class is not intended to be instantiated by clients.
 * @noextend This class is not intended to be subclassed by clients.
 */
public class TextUtilities {

  /** Default line delimiters used by the text functions of this class. */
  public static final String[] DELIMITERS =
      new String[] {"\n", "\r", "\r\n"}; // $NON-NLS-3$ //$NON-NLS-2$ //$NON-NLS-1$

  /**
   * Determines which one of default line delimiters appears first in the list. If none of them the
   * hint is returned.
   *
   * @param text the text to be checked
   * @param hint the line delimiter hint
   * @return the line delimiter
   */
  public static String determineLineDelimiter(String text, String hint) {
    try {
      int[] info = indexOf(DELIMITERS, text, 0);
      return DELIMITERS[info[1]];
    } catch (ArrayIndexOutOfBoundsException x) {
    }
    return hint;
  }

  /**
   * Returns the starting position and the index of the first matching search string in the given
   * text that is greater than the given offset. If more than one search string matches with the
   * same starting position then the longest one is returned.
   *
   * @param searchStrings the strings to search for
   * @param text the text to be searched
   * @param offset the offset at which to start the search
   * @return an <code>int[]</code> with two elements where the first is the starting offset, the
   *     second the index of the found search string in the given <code>searchStrings</code> array,
   *     returns <code>[-1, -1]</code> if no match exists
   */
  public static int[] indexOf(String[] searchStrings, String text, int offset) {

    int[] result = {-1, -1};
    int zeroIndex = -1;

    for (int i = 0; i < searchStrings.length; i++) {

      int length = searchStrings[i].length();

      if (length == 0) {
        zeroIndex = i;
        continue;
      }

      int index = text.indexOf(searchStrings[i], offset);
      if (index >= 0) {

        if (result[0] == -1) {
          result[0] = index;
          result[1] = i;
        } else if (index < result[0]) {
          result[0] = index;
          result[1] = i;
        } else if (index == result[0] && length > searchStrings[result[1]].length()) {
          result[0] = index;
          result[1] = i;
        }
      }
    }

    if (zeroIndex > -1 && result[0] == -1) {
      result[0] = 0;
      result[1] = zeroIndex;
    }

    return result;
  }

  /**
   * Returns the index of the longest search string with which the given text ends or <code>-1
   * </code> if none matches.
   *
   * @param searchStrings the strings to search for
   * @param text the text to search
   * @return the index in <code>searchStrings</code> of the longest string with which <code>text
   *     </code> ends or <code>-1</code>
   */
  public static int endsWith(String[] searchStrings, String text) {

    int index = -1;

    for (int i = 0; i < searchStrings.length; i++) {
      if (text.endsWith(searchStrings[i])) {
        if (index == -1 || searchStrings[i].length() > searchStrings[index].length()) index = i;
      }
    }

    return index;
  }

  /**
   * Returns the index of the longest search string with which the given text starts or <code>-1
   * </code> if none matches.
   *
   * @param searchStrings the strings to search for
   * @param text the text to search
   * @return the index in <code>searchStrings</code> of the longest string with which <code>text
   *     </code> starts or <code>-1</code>
   */
  public static int startsWith(String[] searchStrings, String text) {

    int index = -1;

    for (int i = 0; i < searchStrings.length; i++) {
      if (text.startsWith(searchStrings[i])) {
        if (index == -1 || searchStrings[i].length() > searchStrings[index].length()) index = i;
      }
    }

    return index;
  }

  /**
   * Returns the index of the first compare string that isEquals the given text or <code>-1</code>
   * if none is equal.
   *
   * @param compareStrings the strings to compare with
   * @param text the text to check
   * @return the index of the first equal compare string or <code>-1</code>
   */
  public static int isEquals(String[] compareStrings, String text) {
    for (int i = 0; i < compareStrings.length; i++) {
      if (text.equals(compareStrings[i])) return i;
    }
    return -1;
  }

  /**
   * Returns a document event which is an accumulation of a list of document events, <code>null
   * </code> if the list of documentEvents is empty. The document of the document events are
   * ignored.
   *
   * @param unprocessedDocument the document to which the document events would be applied
   * @param documentEvents the list of document events to merge
   * @return returns the merged document event
   * @throws BadLocationException might be thrown if document is not in the correct state with
   *     respect to document events
   */
  public static DocumentEvent mergeUnprocessedDocumentEvents(
      Document unprocessedDocument, List<DocumentEvent> documentEvents)
      throws BadLocationException {

    if (documentEvents.size() == 0) return null;

    final Iterator<DocumentEvent> iterator = documentEvents.iterator();
    final DocumentEvent firstEvent = iterator.next();

    // current merged event
    final Document document = unprocessedDocument;
    int offset = firstEvent.getOffset();
    int length = firstEvent.getLength();
    final StringBuffer text =
        new StringBuffer(firstEvent.getText() == null ? "" : firstEvent.getText()); // $NON-NLS-1$

    while (iterator.hasNext()) {

      final int delta = text.length() - length;

      final DocumentEvent event = (DocumentEvent) iterator.next();
      final int eventOffset = event.getOffset();
      final int eventLength = event.getLength();
      final String eventText = event.getText() == null ? "" : event.getText(); // $NON-NLS-1$

      // event is right from merged event
      if (eventOffset > offset + length + delta) {
        final String string =
            document.get(offset + length, (eventOffset - delta) - (offset + length));
        text.append(string);
        text.append(eventText);

        length = (eventOffset - delta) + eventLength - offset;

        // event is left from merged event
      } else if (eventOffset + eventLength < offset) {
        final String string =
            document.get(eventOffset + eventLength, offset - (eventOffset + eventLength));
        text.insert(0, string);
        text.insert(0, eventText);

        length = offset + length - eventOffset;
        offset = eventOffset;

        // events overlap each other
      } else {
        final int start = Math.max(0, eventOffset - offset);
        final int end = Math.min(text.length(), eventLength + eventOffset - offset);
        text.replace(start, end, eventText);

        offset = Math.min(offset, eventOffset);
        final int totalDelta = delta + eventText.length() - eventLength;
        length = text.length() - totalDelta;
      }
    }

    return new DocumentEvent(document, offset, length, text.toString());
  }

  /**
   * Returns a document event which is an accumulation of a list of document events, <code>null
   * </code> if the list of document events is empty. The document events being merged must all
   * refer to the same document, to which the document changes have been already applied.
   *
   * @param documentEvents the list of document events to merge
   * @return returns the merged document event
   * @throws BadLocationException might be thrown if document is not in the correct state with
   *     respect to document events
   */
  public static DocumentEvent mergeProcessedDocumentEvents(List<DocumentEvent> documentEvents)
      throws BadLocationException {

    if (documentEvents.size() == 0) return null;

    final ListIterator<DocumentEvent> iterator = documentEvents.listIterator(documentEvents.size());
    final DocumentEvent firstEvent = iterator.previous();

    // current merged event
    final Document document = firstEvent.getDocument();
    int offset = firstEvent.getOffset();
    int length = firstEvent.getLength();
    int textLength = firstEvent.getText() == null ? 0 : firstEvent.getText().length();

    while (iterator.hasPrevious()) {

      final int delta = length - textLength;

      final DocumentEvent event = (DocumentEvent) iterator.previous();
      final int eventOffset = event.getOffset();
      final int eventLength = event.getLength();
      final int eventTextLength = event.getText() == null ? 0 : event.getText().length();

      // event is right from merged event
      if (eventOffset > offset + textLength + delta) {
        length = (eventOffset - delta) - (offset + textLength) + length + eventLength;
        textLength = (eventOffset - delta) + eventTextLength - offset;

        // event is left from merged event
      } else if (eventOffset + eventTextLength < offset) {
        length = offset - (eventOffset + eventTextLength) + length + eventLength;
        textLength = offset + textLength - eventOffset;
        offset = eventOffset;

        // events overlap each other
      } else {
        final int start = Math.max(0, eventOffset - offset);
        final int end = Math.min(length, eventTextLength + eventOffset - offset);
        length += eventLength - (end - start);

        offset = Math.min(offset, eventOffset);
        final int totalDelta = delta + eventLength - eventTextLength;
        textLength = length - totalDelta;
      }
    }

    final String text = document.get(offset, textLength);
    return new DocumentEvent(document, offset, length, text);
  }

  /**
   * Removes all connected document partitioners from the given document and stores them under their
   * partitioning name in a map. This map is returned. After this method has been called the given
   * document is no longer connected to any document partitioner.
   *
   * @param document the document
   * @return the map containing the removed partitioners (key type: {@link String}, value type:
   *     {@link DocumentPartitioner})
   */
  public static Map<String, DocumentPartitioner> removeDocumentPartitioners(Document document) {
    Map<String, DocumentPartitioner> partitioners = new HashMap<String, DocumentPartitioner>();

    String[] partitionings = document.getPartitionings();
    for (int i = 0; i < partitionings.length; i++) {
      DocumentPartitioner partitioner = document.getDocumentPartitioner(partitionings[i]);
      if (partitioner != null) {
        document.setDocumentPartitioner(partitionings[i], null);
        partitioner.disconnect();
        partitioners.put(partitionings[i], partitioner);
      }
    }
    //      }
    //      else
    //      {
    //         IDocumentPartitioner partitioner = document.getDocumentPartitioner();
    //         if (partitioner != null)
    //         {
    //            document.setDocumentPartitioner(null);
    //            partitioner.disconnect();
    //            partitioners.put(IDocumentExtension3.DEFAULT_PARTITIONING, partitioner);
    //         }
    //      }
    return partitioners;
  }

  /**
   * Connects the given document with all document partitioners stored in the given map under their
   * partitioning name. This method cleans the given map.
   *
   * @param document the document
   * @param partitioners the map containing the partitioners to be connected (key type: {@link
   *     String}, value type: {@link DocumentPartitioner})
   */
  public static void addDocumentPartitioners(
      Document document, Map<String, DocumentPartitioner> partitioners) {
    Iterator<String> e = partitioners.keySet().iterator();
    while (e.hasNext()) {
      String partitioning = e.next();
      DocumentPartitioner partitioner = partitioners.get(partitioning);
      partitioner.connect(document);
      document.setDocumentPartitioner(partitioning, partitioner);
    }
    partitioners.clear();
    //      }
    //      else
    //      {
    //         IDocumentPartitioner partitioner =
    //            (IDocumentPartitioner)partitioners.get(IDocumentExtension3.DEFAULT_PARTITIONING);
    //         partitioner.connect(document);
    //         document.setDocumentPartitioner(partitioner);
    //      }
  }

  /**
   * Returns the content type at the given offset of the given document.
   *
   * @param document the document
   * @param partitioning the partitioning to be used
   * @param offset the offset
   * @param preferOpenPartitions <code>true</code> if precedence should be given to a open partition
   *     ending at <code>offset</code> over a closed partition starting at <code>offset</code>
   * @return the content type at the given offset of the document
   * @throws BadLocationException if offset is invalid in the document
   */
  public static String getContentType(
      Document document, String partitioning, int offset, boolean preferOpenPartitions)
      throws BadLocationException {
    try {
      return document.getContentType(partitioning, offset, preferOpenPartitions);
    } catch (BadPartitioningException x) {
      return Document.DEFAULT_CONTENT_TYPE;
    }

    //      return document.getContentType(offset);
  }

  /**
   * Returns the partition of the given offset of the given document.
   *
   * @param document the document
   * @param partitioning the partitioning to be used
   * @param offset the offset
   * @param preferOpenPartitions <code>true</code> if precedence should be given to a open partition
   *     ending at <code>offset</code> over a closed partition starting at <code>offset</code>
   * @return the content type at the given offset of this viewer's input document
   * @throws BadLocationException if offset is invalid in the given document
   */
  public static TypedRegion getPartition(
      Document document, String partitioning, int offset, boolean preferOpenPartitions)
      throws BadLocationException {
    try {
      return document.getPartition(partitioning, offset, preferOpenPartitions);
    } catch (BadPartitioningException x) {
      return new TypedRegionImpl(0, document.getLength(), Document.DEFAULT_CONTENT_TYPE);
    }
    //      return document.getPartition(offset);
  }

  /**
   * Computes and returns the partitioning for the given region of the given document for the given
   * partitioning name.
   *
   * @param document the document
   * @param partitioning the partitioning name
   * @param offset the region offset
   * @param length the region length
   * @param includeZeroLengthPartitions whether to include zero-length partitions
   * @return the partitioning for the given region of the given document for the given partitioning
   *     name
   * @throws BadLocationException if the given region is invalid for the given document
   */
  public static TypedRegion[] computePartitioning(
      Document document,
      String partitioning,
      int offset,
      int length,
      boolean includeZeroLengthPartitions)
      throws BadLocationException {
    try {
      return document.computePartitioning(
          partitioning, offset, length, includeZeroLengthPartitions);
    } catch (BadPartitioningException x) {
      return new TypedRegion[0];
    }

    //      return document.computePartitioning(offset, length);
  }

  // /**
  // * Computes and returns the partition managing position categories for the given document or
  // <code>null</code> if this was
  // * impossible.
  // *
  // * @param document the document
  // * @return the partition managing position categories or <code>null</code>
  // * @since 3.0
  // */
  // public static String[] computePartitionManagingCategories(IDocument document)
  // {
  // if (document instanceof IDocumentExtension3)
  // {
  // IDocumentExtension3 extension3 = (IDocumentExtension3)document;
  // String[] partitionings = extension3.getPartitionings();
  // if (partitionings != null)
  // {
  // Set categories = new HashSet();
  // for (int i = 0; i < partitionings.length; i++)
  // {
  // IDocumentPartitioner p = extension3.getDocumentPartitioner(partitionings[i]);
  // if (p instanceof IDocumentPartitionerExtension2)
  // {
  // IDocumentPartitionerExtension2 extension2 = (IDocumentPartitionerExtension2)p;
  // String[] c = extension2.getManagingPositionCategories();
  // if (c != null)
  // {
  // for (int j = 0; j < c.length; j++)
  // categories.add(c[j]);
  // }
  // }
  // }
  // String[] result = new String[categories.size()];
  // categories.toArray(result);
  // return result;
  // }
  // }
  // return null;
  // }

  /**
   * Returns the default line delimiter for the given document. This is either the delimiter of the
   * first line, or the platform line delimiter if it is a legal line delimiter or the first one of
   * the legal line delimiters. The default line delimiter should be used when performing document
   * manipulations that span multiple lines.
   *
   * @param document the document
   * @return the document's default line delimiter
   */
  public static String getDefaultLineDelimiter(Document document) {

    // if (document instanceof IDocumentExtension4)
    // return ((IDocumentExtension4)document).getDefaultLineDelimiter();

    String lineDelimiter = null;

    try {
      lineDelimiter = document.getLineDelimiter(0);
    } catch (BadLocationException x) {
    }

    if (lineDelimiter != null) return lineDelimiter;

    String sysLineDelimiter = "\n"; // System.getProperty("line.separator"); //$NON-NLS-1$
    String[] delimiters = document.getLegalLineDelimiters();
    Assert.isTrue(delimiters.length > 0);
    for (int i = 0; i < delimiters.length; i++) {
      if (delimiters[i].equals(sysLineDelimiter)) {
        lineDelimiter = sysLineDelimiter;
        break;
      }
    }

    if (lineDelimiter == null) lineDelimiter = delimiters[0];

    return lineDelimiter;
  }

  /**
   * Returns <code>true</code> if the two regions overlap. Returns <code>false</code> if one of the
   * arguments is <code>null</code>.
   *
   * @param left the left region
   * @param right the right region
   * @return <code>true</code> if the two regions overlap, <code>false</code> otherwise
   */
  public static boolean overlaps(Region left, Region right) {

    if (left == null || right == null) return false;

    int rightEnd = right.getOffset() + right.getLength();
    int leftEnd = left.getOffset() + left.getLength();

    if (right.getLength() > 0) {
      if (left.getLength() > 0) return left.getOffset() < rightEnd && right.getOffset() < leftEnd;
      return right.getOffset() <= left.getOffset() && left.getOffset() < rightEnd;
    }

    if (left.getLength() > 0)
      return left.getOffset() <= right.getOffset() && right.getOffset() < leftEnd;

    return left.getOffset() == right.getOffset();
  }

  /**
   * Returns a copy of the given string array.
   *
   * @param array the string array to be copied
   * @return a copy of the given string array or <code>null</code> when <code>array</code> is <code>
   *     null</code>
   */
  public static String[] copy(String[] array) {
    if (array != null) {
      String[] copy = new String[array.length];
      System.arraycopy(array, 0, copy, 0, array.length);
      return copy;
    }
    return null;
  }

  /**
   * Returns a copy of the given integer array.
   *
   * @param array the integer array to be copied
   * @return a copy of the given integer array or <code>null</code> when <code>array</code> is
   *     <code>null</code>
   */
  public static int[] copy(int[] array) {
    if (array != null) {
      int[] copy = new int[array.length];
      System.arraycopy(array, 0, copy, 0, array.length);
      return copy;
    }
    return null;
  }

  /**
   * Return document offset by cursor position(line, column)
   *
   * @param document the document to offset
   * @param line the cursor line
   * @param column the cursor column
   * @return offset of cursor or <code>-1</code> if BadLocationException occurs
   */
  public static int getOffset(Document document, int line, int column) {
    try {
      int lineOffset = document.getLineOffset(line);
      return lineOffset + column;
    } catch (BadLocationException e) {
      Log.error(TextUtilities.class, e);
      return -1;
    }
  }

  /**
   * @param document
   * @param offset
   * @return
   */
  public static int getLineLineNumber(Document document, int offset) {
    try {
      return document.getLineOfOffset(offset);
    } catch (BadLocationException e) {
      return 0;
    }
  }
}
